package 重写;
/**
 * 多态
 *
 * 1.完成向上转型
 * 2.完成方法的重写
 * 3.通过夫类的引用 调用 这个重写的方法
 */

/**
 * 满足方法重写的条件
 * 1.方法名相同
 * 2.返回真相同（返回值也可以是夫子类关系【协变类型】）
 * 3.方法的参数列表相同（个数，类型. 顺序）
 * 4.static 修饰的方法不能被重写
 * 5private修饰的方法不能被重写
 * 6.子类的访问修饰符.需要大于等于父类的访问修饰符
 */
class Animal{
    private String name;
    private  int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }



    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //加上个final:这个方法是不能被重写的 【 密封方法】
    public void eat(){
        System.out.println(getName()+"正在吃鸟粮");
    }
    public void fly(){
        System.out.println(getName()+"正在飞");
    }
}



class Bird extends Animal{


    public Bird(String name, int age) {
        super(name, age);
    }

    @Override
    public   void fly(){
        System.out.println(getName()+"正在飞");

    }



}
class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }

    public void eat(){
        System.out.println(getName()+"正在狗粮");
    }
}

public class Test {

    public static void func(Animal animal){
        animal.eat();
    }

    public static void main(String[] args) {
        func(new Bird("小鸟",1));
        func(new Dog("狗子",2));

    }
    public static void main1(String[] args) {

        Animal animal=new Bird("鸟",2);
        animal.eat();//动态绑定
        Animal animal1=new Animal("狗",2);
        animal1.eat();

    }
}
